import { get } from "http";
import { Connection } from "./connection";
import { connectionManger } from "./connectionmanager";
import { mysqlTransaction } from "./mysqltransaction";
import { error } from "console";
import { Transaction } from "./transaction";

export async function getConnection(): Promise<any> {
    return await connectionManger.createConnection()
}

/**
 * 在事务开启，事务提交和事务回滚时，先判断事务计数属性值，
 * 当事务计数属性值为1时，才进行实际事务操作
 * 嵌套的内层里面实际没有实际的事务的，只有最外层一个整体的事务的实际的事务
 */
export async function beginTransction() {
    let conn =await getConnection()
    // let tx : mysqlTransaction = connectionManger.getTransaction(conn)
    const tx = new Transaction(conn);


    // 开始一个事务，事务的嵌套级别加1
    ++Transaction.transactionNestingLelvel

    // 如果事务的嵌套级别为1
    if (Transaction.transactionNestingLelvel === 1) {
        // 在数据库连接上开始一个事务
        //await tx.begin()
        await tx.tx.begin();
    }else{
        tx.createSavepoint()


    }
    // 如果允许嵌套事务
    // else if (this.nestTransactionWithSavepoints) {
        // 创建一个保存点，保存事务的状态
        

        
    // }
}

export async function commitTransaciton(): Promise<void> {
    // let conn =await getConnection()
    // let tx : mysqlTransaction = connectionManger.getTransaction(conn)
    // // 如果事务嵌套级别为0，则抛出noactivetransaction()异常
    // if (this.transactionNestingLelvel === 0) {
    //     //没有激活的事务
    //     throw error
    //     // throw noactivetransaction();
    // }
    // // 如果只能回滚，则抛出comitfailrollbackonly()异常
    // if (this.isrollbackonly) {
    //     throw comitfailrollbackonly();
    // }
    // // 如果事务嵌套级别为1，则提交实际事务
    // if (this.transactionNestingLelvel === 1) {
    //     this.conn.commit();
    // } 
    // // 如果使用保存点进行嵌套事务，则释放保存点
    // else if (this.nestTransactionWithSavepoints) {
    //     this.releaseSavepoint(this.getNestTransactionSavePointName());
    // }
    // // 事务嵌套级别减1
    // --this.transactionNestingLelvel
    const conn = await getConnection();
    const tx = new Transaction(conn);
    if (Transaction.transactionNestingLelvel === 1) {
        await tx.tx.commit();
    } else {
        await tx.releaseSavepoint();
    }
    Transaction.transactionNestingLelvel--;
}

export async function rollbackTransaction() {
    // let conn =await getConnection()
    // let tx : mysqlTransaction = connectionManger.getTransaction(conn)
    // // 如果当前事务嵌套级别为0，则抛出没有活动事务异常
    // if (this.transactionNestingLevel == 0) {
    //     throw new ConnectionException("没有活动事务");
    // }
    // // 如果当前事务嵌套级别为1，则进行事务回滚
    // if (this.transactionNestingLevel === 1) {
    //     this.transactionNestingLevel = 0;
    //     this.conn.rollback();
    //     this.isrollbackonly = false;
    // } 
    // // 如果使用了保存点事务嵌套，则回滚到保存点，然后减少事务嵌套级别
    // else if (this.nestTransactionWithSavepoints) {
    //     this.rollbackToSavepoint(this.getNestTransactionSavePointName());
    //     --this.transactionNestingLevel;
    // } 
    // // 否则只进行事务回滚，然后减少事务嵌套级别
    // else {
    //     this.isrollbackonly = true;
    //     --this.transactionNestingLevel;
    // }

    const conn = await getConnection();
    const tx = new Transaction(conn);
    if (Transaction.transactionNestingLelvel === 1) {
        await tx.tx.rollback();
    } else {
        await tx.rollbackToSavepoint();
    }
    Transaction.transactionNestingLelvel--;
}

export async function closeConnection() {
    // const conn = await getConnection();
    // await connectionManger.close(conn);
    return connectionManger.release()
}